using System;
using System.Collections.Generic;
using System.Threading;
using LDNS.Interfaces;
using LDNS.Models;
using LDNS.Utilities;
using LDNS.Api;
using NLog;

namespace LDNS.Services
{
    /// <summary>
    /// DNS服务主要功能类，提供DNS服务的初始化和管理功能
    /// 作者：huobing
    /// </summary>
    public class DnsServiceManager
    {
        private IDnsService? _dnsService;
        private Logger _logger = LogManager.GetCurrentClassLogger();
        private DnsConfigManager? _configManager;
        private ManualResetEvent _shutdownEvent = new ManualResetEvent(false);
        private CancellationTokenSource? _cancellationTokenSource;
        private bool _isRunning = false;
        // 新增：Named Pipes命令服务端
        private NamedPipeServer? _pipeServer;

        /// <summary>
        /// 运行DNS服务的主要方法
        /// </summary>
        /// <param name="options">DNS服务选项</param>
        /// <returns>是否启动成功</returns>
        public bool Run(DnsServiceOptions options)
        {
            try
            {
                // 这里先使用Console，因为_logger还未初始化
                _logger.Info("=== LDNS Service 启动中 ===");

                // 初始化选项
                DnsServiceOptions _options = options ?? new DnsServiceOptions();
                
                // 初始化组件
                InitializeComponents(_options);
                
                // 设置控制台事件处理
                SetupConsoleHandlers();
                
                // 启动DNS服务
                if (StartDnsService(_options))
                {
                    _isRunning = true;
                    _logger.Info($"DNS服务启动成功，监听端口: {_dnsService?.Port}");
                    
                    // 等待关闭信号
                    WaitForShutdown();
                    
                    _isRunning = false;
                    return true;
                }
                else
                {
                    _logger.Error("DNS服务启动失败");
                    return false;
                }
            }
            catch (Exception ex)
            {
                // 如果_logger已初始化则使用它，否则使用Console
                _logger.Error($"启动DNS服务时发生严重错误: {ex.Message}", ex);
                return false;
            }
            finally
            {
                // 清理资源
                Cleanup();
                
                // 这里使用Console，因为这是最后一条消息
                _logger.Info("=== DNS Service 已停止 ===");
            }
        }

        /// <summary>
        /// 初始化组件
        /// </summary>
        /// <param name="options">DNS服务选项</param>
        private void InitializeComponents(DnsServiceOptions options)
        {
            try
            {
                // 创建配置管理器（使用单例）
                _configManager = DnsConfigManager.GetInstance(options);
                // 使用Logger记录配置加载信息
                _logger.Debug("=== 配置加载调试信息 ===");
                _logger.Debug($"配置文件路径: Conf/DNSService.conf");
                _logger.Debug($"IsEnabled: {_configManager.Config.IsEnabled}");
                _logger.Debug($"Port: {_configManager.Config.Port}");
                _logger.Debug($"上游DNS服务器数量: {_configManager.Config.UpstreamDnsServers?.Count ?? 0}");
                if (_configManager.Config.UpstreamDnsServers != null)
                {
                    foreach (var server in _configManager.Config.UpstreamDnsServers)
                    {
                        _logger.Debug($"  - {server}");
                    }
                }
                _logger.Debug("=== 配置调试信息结束 ===");
                // 创建DNS服务
                _dnsService = new LocalDNSService();
                
                // 设置DNS记录
                foreach (var record in _configManager.DnsRecordManager.DnsRecords.Values)
                {
                    DnsRecordManager.Instance.AddDnsRecord(record.Domain, record.IP, record.RecordType, record.Ttl, record.Description);
                }
                
                _logger.Info("组件初始化完成");
            }
            catch (Exception ex)
            {
                throw new Exception($"初始化组件失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 设置控制台事件处理
        /// </summary>
        private void SetupConsoleHandlers()
        {
            try
            {
                _cancellationTokenSource = new CancellationTokenSource();
                
                // 设置Ctrl+C事件处理
                Console.CancelKeyPress += (sender, e) =>
                {
                    e.Cancel = true;
                    _logger.Info("收到停止信号，正在关闭服务...");
                    _cancellationTokenSource?.Cancel();
                };
                
                _logger.Info("控制台事件处理已设置");
            }
            catch (Exception ex)
            {
                throw new Exception($"设置控制台事件处理失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 启动DNS服务
        /// </summary>
        /// <param name="options">DNS服务选项</param>
        /// <returns>是否启动成功</returns>
        private bool StartDnsService(DnsServiceOptions options)
        {
            try
            {
                if (_dnsService == null)
                {
                    _logger.Error("DNS服务未初始化");
                    return false;
                }
                
                var config = _configManager?.LoadConfig();
                if (config == null)
                {
                    _logger.Error("无法加载配置");
                    return false;
                }
                
                _logger.Info("开始启动DNS服务");
                
                bool success = _dnsService.Start();
                
                _logger.Debug($"_dnsService.Start()返回: {success}");
                
                if (success)
                {
                    _logger.Info($"DNS服务已启动，监听端口: {config.Port}");
                    // 启动Named Pipes命令服务端（仅在服务成功启动后）
                    var dnsSvc = _dnsService as LocalDNSService;
                    var cfgMgr = _configManager as DnsConfigManager;
                    if (dnsSvc != null && cfgMgr != null)
                    {
                        _pipeServer = new NamedPipeServer(dnsSvc, cfgMgr);
                        _pipeServer.Start();
                        _logger.Info("IPC管道服务已启动，等待UI连接");
                    }
                    else
                    {
                        _logger.Warn("无法初始化IPC管道服务：类型转换失败");
                    }
                    return true;
                }
                else
                {
                    _logger.Error($"DNS服务启动失败，端口: {config.Port}");
                    return false;
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"启动DNS服务时发生错误: {ex.Message}", ex);
                return false;
            }
        }

        /// <summary>
        /// 等待关闭信号
        /// </summary>
        private void WaitForShutdown()
        {
            try
            {
                // 使用取消令牌等待，而不是无限期等待事件
                if (_cancellationTokenSource != null)
                {
                    try
                    {
                        // 等待取消令牌被取消
                        _cancellationTokenSource.Token.WaitHandle.WaitOne();
                    }
                    catch (OperationCanceledException)
                    {
                        // 正常取消，不做处理
                    }
                }
                else
                {
                    // 如果没有取消令牌，使用简单的等待
                    Thread.Sleep(Timeout.Infinite);
                }
                
                _logger.Info("收到关闭信号，正在停止服务...");
            }
            catch (Exception ex)
            {
                _logger.Error($"等待关闭信号时发生错误: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 清理资源
        /// </summary>
        private void Cleanup()
        {
            try
            {
                _logger.Info("正在清理资源...");
                
                // 停止DNS服务
                _dnsService?.Stop();
                // 停止IPC管道服务
                _pipeServer?.Stop();
                _pipeServer = null;
                
                // 监控服务已移除，无需停止
                _dnsService?.Dispose();
                _configManager?.Dispose();
                _cancellationTokenSource?.Dispose();
                
                _logger.Info("资源清理完成");
            }
            catch (Exception ex)
            {
                _logger.Error($"清理资源时发生错误: {ex.Message}", ex);
            }
        }
        


        /// <summary>
        /// 停止DNS服务
        /// </summary>
        public void StopService()
        {
            try
            {
                _logger.Info("正在停止DNS服务...");
                
                // 停止DNS服务
                if (_isRunning && _dnsService != null)
                {
                    _dnsService.Stop();
                    _dnsService.Dispose();
                    _isRunning = false;
                }
                
                // 停止IPC管道服务
                if (_pipeServer != null)
                {
                    _pipeServer.Stop();
                    _pipeServer = null;
                }
                
                // 监控服务已移除，无需停止
                
                // 释放资源
                _configManager?.Dispose();
                _cancellationTokenSource?.Dispose();
                _logger.Info("DNS服务已完全停止并清理资源");
            }
            catch (Exception ex)
            {
                _logger.Error($"停止服务时发生错误: {ex.Message}", ex);
            }
        }
    }
}